#include "Image_Viewer.h"
#include "NavigationController.h"
#include <QPixmap>
#include <QBuffer>
#include <QMessageBox>
#include <MainPage.h>
#include <QStackedLayout>
#include <QPalette>
#include <opencv2/opencv.hpp>
#include <QDebug>
#include <QMessageBox>
#include <QDateTime>
#include <QDir>

Image_Viewer::Image_Viewer(QWidget *parent)
    : QWidget(parent), ui(new Ui::Image_Viewer)

{
    ui->setupUi(this);
    cameraLabel = ui->label;
    cameraLabel2 = ui->label_11;

    // 创建PicShowLabel1
    PicShowLabel1 = new QLabel(this);

    // 获取屏幕大小
    QScreen *screen = QGuiApplication::primaryScreen();
    QRect screenGeometry = screen->geometry();

    // 设置PicShowLabel的位置和大小（例如在屏幕中央显示200x200的区域）
    int x = 250; // 居中
    int y = 150; // 居中
    // int x=200;
    // int y=200;
    int width = 300;
    int height = 300;

    // 设置PicShowLabel的几何属性
    PicShowLabel1->setGeometry(x, y, width, height);

    // 可选：设置PicShowLabel的样式
    PicShowLabel1->setStyleSheet("border: none;"); // 为PicShowLabel添加边框
}


Image_Viewer::~Image_Viewer()
{
    delete ui;
    cap.release();
    delete timer;
}

void Image_Viewer::updateCameraFrame()
{
    cv::Mat frame;
    cap >> frame;
    if (frame.empty()) {
        qDebug() << "无法读取数据";
        QMessageBox::critical(this, "错误", "无法从摄像头读取数据");
        return;
    }
    QImage img = MatToQImage(frame);
    cameraLabel->setPixmap(QPixmap::fromImage(img));
}

QImage Image_Viewer::MatToQImage(const cv::Mat &mat)
{
    if (mat.type() == CV_8UC1) {
        QImage image(mat.cols, mat.rows, QImage::Format_Grayscale8);
        uchar *ptr = image.bits();
        for (int i = 0; i < mat.rows; ++i) {
            memcpy(ptr, mat.ptr(i), mat.cols);
            ptr += image.bytesPerLine();
        }
        return image;
    } else if (mat.type() == CV_8UC3) {
        const uchar *qImgBuf = (const uchar*)mat.data;
        QImage img(qImgBuf, mat.cols, mat.rows, mat.step, QImage::Format_RGB888);
        return img.rgbSwapped();
    } else {
        qDebug() << "cv::Mat image type not handled in switch:" << mat.type();
        return QImage();
    }
}
void Image_Viewer::on_dakaiBt_clicked()
{
    // 打开文件夹选择对话框
    QString folderPath = QFileDialog::getExistingDirectory(this, "选择文件夹");

    // 检查用户是否选择了有效的文件夹
    if (folderPath.isEmpty()) {
        return;
    }

    // 获取文件夹中的所有图片文件
    QDir directory(folderPath);
    QStringList filters;
    filters << "*.png" << "*.jpg" << "*.jpeg" << "*.bmp" << "*.gif"; // 支持的图片格式
    QFileInfoList fileList = directory.entryInfoList(filters, QDir::Files);

    // 清空PiclistWidget
    //PiclistWidget->clear();

    // 清空PicShowLabel
    PicShowLabel1->clear();

    // 如果没有找到图片文件
    if (fileList.isEmpty()) {
        return;
    }

    // 设置PiclistWidget的视图模式为图标模式
    ui->PiclistWidget->setViewMode(QListWidget::IconMode);
    ui->PiclistWidget->setFlow(QListWidget::LeftToRight); // 横向排列
    ui->PiclistWidget->setWrapping(false); // 不换行，保持横向排列
    ui->PiclistWidget->setSpacing(10); // 设置项之间的间距
    ui->PiclistWidget->setIconSize(QSize(170, 100)); // 设置图标大小

    // 设置PiclistWidget的水平滚动条策略为自动显示
    ui->PiclistWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);

    // 设置缩略图高度为 77 像素，宽度按比例显示
    const int thumbnailHeight = 77;

    // 添加图片文件到PiclistWidget，并设置第一张图片
    QString firstImagePath;
    for (const QFileInfo &fileInfo : fileList) {
        // 生成缩略图
        QImage image(fileInfo.filePath());
        if (!image.isNull()) {
            int originalWidth = image.width();
            int originalHeight = image.height();
            int scaledWidth = (thumbnailHeight * originalWidth) / originalHeight;

            QPixmap pixmap = QPixmap::fromImage(image).scaled(scaledWidth, thumbnailHeight, Qt::KeepAspectRatio, Qt::SmoothTransformation);
            qDebug() << "Thumbnail Width:" << scaledWidth << "Thumbnail Height:" << thumbnailHeight;
            // 添加图片到列表，显示文本
            QListWidgetItem *item = new QListWidgetItem(QIcon(pixmap), fileInfo.fileName(), ui->PiclistWidget);
            item->setData(Qt::UserRole, fileInfo.filePath());

            // 设置第一张图片
            if (firstImagePath.isEmpty()) {
                firstImagePath = fileInfo.filePath();
            }
        }
    }

    // 显示第一张图片
    if (!firstImagePath.isEmpty()) {
        QImage image(firstImagePath);
        if (!image.isNull()) {
            PicShowLabel1->setPixmap(QPixmap::fromImage(image));
        }
    }
    ui->PiclistWidget->setStyleSheet(
        "background-color: #B0E0E6;"
        "border: 1px solid #dcdcdc;" // 边框颜色
        "border-radius: 5px;"       // 边框圆角
        );
    // 连接PiclistWidget的项选择信号，显示选中的图片
    connect(ui->PiclistWidget, &QListWidget::currentItemChanged, [this](QListWidgetItem *current, QListWidgetItem *) {
        if (current) {
            QString imagePath = current->data(Qt::UserRole).toString();
            QImage image(imagePath);
            if (!image.isNull()) {
                QPixmap pixmap = QPixmap::fromImage(image);

                // 设置图片大小为 PicShowLabel1 的大小
                QSize labelSize = PicShowLabel1->size();
                QPixmap scaledPixmap = pixmap.scaled(labelSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);

                // 设置缩放后的图片到 PicShowLabel1
                PicShowLabel1->setPixmap(scaledPixmap);

                // 确保图片居中显示
                PicShowLabel1->setAlignment(Qt::AlignCenter);
            }
        }
    });
}

void Image_Viewer::on_deleteBt_clicked()
{
    // 获取PicShowLabel1中当前显示的图片路径
    QString currentImagePath = ui->PiclistWidget->currentItem()->data(Qt::UserRole).toString();

    // 检查当前图片路径是否有效
    if (currentImagePath.isEmpty()) {
        return;
    }

    // 删除图片文件
    QFile file(currentImagePath);
    if (file.exists()) {
        file.remove();
    }

    // 从PiclistWidget中移除对应的项
    QListWidgetItem *currentItem = ui->PiclistWidget->currentItem();
    delete currentItem;

    // 如果PiclistWidget中没有更多的项，则清空PicShowLabel1
    if (ui->PiclistWidget->count() == 0) {
        PicShowLabel1->clear();
        return;
    }

    // 如果有更多的项，选择并显示下一张图片
    QListWidgetItem *nextItem = ui->PiclistWidget->currentItem();
    if (!nextItem) {
        nextItem = ui->PiclistWidget->item(0); // 如果没有选中项，则选择第一项
    }
    ui->PiclistWidget->setCurrentItem(nextItem);
}


void Image_Viewer::on_daBt_clicked()
{
    // 获取当前显示的图片
    QPixmap currentPixmap = PicShowLabel1->pixmap();
    if (currentPixmap.isNull()) {
        return;
    }

    // 计算放大倍数
    const double scaleFactor = 1.25; // 放大1.5倍

    // 放大图像
    QSize newSize = currentPixmap.size() * scaleFactor;
    QPixmap scaledPixmap = currentPixmap.scaled(newSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);

    // 设置放大后的图片到PicShowLabel1
    PicShowLabel1->setPixmap(scaledPixmap);

    // 确保图片居中显示
    PicShowLabel1->setAlignment(Qt::AlignCenter);
}


void Image_Viewer::on_xiaoBt_clicked()
{
    // 获取当前显示的图片
    QPixmap currentPixmap = PicShowLabel1->pixmap();
    if (currentPixmap.isNull()) {
        return;
    }

    // 计算放大倍数
    const double scaleFactor = 0.75; // 放大1.5倍

    // 放大图像
    QSize newSize = currentPixmap.size() * scaleFactor;
    QPixmap scaledPixmap = currentPixmap.scaled(newSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);

    // 设置放大后的图片到PicShowLabel1
    PicShowLabel1->setPixmap(scaledPixmap);

    // 确保图片居中显示
    PicShowLabel1->setAlignment(Qt::AlignCenter);
}


void Image_Viewer::on_youzhuanBt_clicked()
{
    if (!PicShowLabel1->pixmap()) {
        // 如果没有图片，直接返回
        return;
    }

    // 获取当前显示的 QPixmap
    QPixmap pixmap = PicShowLabel1->pixmap();

    // 创建一个 QImage 从 QPixmap
    QImage image = pixmap.toImage();

    // 创建一个 QTransform 对象，设置旋转 90 度
    QTransform transform;
    transform.rotate(90);

    // 应用旋转变换到 QImage
    QImage rotatedImage = image.transformed(transform, Qt::SmoothTransformation);

    // 将旋转后的 QImage 转换回 QPixmap
    QPixmap rotatedPixmap = QPixmap::fromImage(rotatedImage);

    // 更新 PicShowLabel1 显示旋转后的图像
    PicShowLabel1->setPixmap(rotatedPixmap);
}


void Image_Viewer::on_zuozhuanBt_clicked()
{
    if (!PicShowLabel1->pixmap()) {
        // 如果没有图片，直接返回
        return;
    }

    // 获取当前显示的 QPixmap
    QPixmap pixmap = PicShowLabel1->pixmap();

    // 创建一个 QImage 从 QPixmap
    QImage image = pixmap.toImage();

    // 创建一个 QTransform 对象，设置旋转 270 度
    QTransform transform;
    transform.rotate(270);

    // 应用旋转变换到 QImage
    QImage rotatedImage = image.transformed(transform, Qt::SmoothTransformation);

    // 将旋转后的 QImage 转换回 QPixmap
    QPixmap rotatedPixmap = QPixmap::fromImage(rotatedImage);

    // 更新 PicShowLabel1 显示旋转后的图像
    PicShowLabel1->setPixmap(rotatedPixmap);
}


void Image_Viewer::on_youBt_clicked()
{
    // 获取当前显示的 QPixmap 对象
    QPixmap  currentPixmap = PicShowLabel1->pixmap();
    if (!currentPixmap) {
        return; // 如果没有显示图片，退出
    }

    // 获取当前显示图片的路径（注意：QPixmap 本身不保存路径信息）
    // 这里假设你有一种方式来保存和获取当前图片路径

    // 获取图片列表中的项
    QListWidgetItem *currentItem = ui->PiclistWidget->currentItem();
    if (!currentItem) {
        return; // 没有选中的项，退出
    }

    // 找到当前图片在列表中的位置
    int currentIndex = ui->PiclistWidget->row(currentItem);
    int nextIndex = (currentIndex + 1) % ui->PiclistWidget->count(); // 循环到列表开头

    // 获取下一张图片的路径
    QListWidgetItem *nextItem = ui->PiclistWidget->item(nextIndex);
    if (nextItem) {
        QString nextImagePath = nextItem->data(Qt::UserRole).toString();

        // 显示下一张图片
        QImage image(nextImagePath);
        if (!image.isNull()) {
            QPixmap pixmap = QPixmap::fromImage(image);

            // 设置图片大小为 PicShowLabel1 的大小
            QSize labelSize = PicShowLabel1->size();
            QPixmap scaledPixmap = pixmap.scaled(labelSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);

            // 设置缩放后的图片到 PicShowLabel1
            PicShowLabel1->setPixmap(scaledPixmap);

            // 确保图片居中显示
            PicShowLabel1->setAlignment(Qt::AlignCenter);

            // 选中下一张图片
            ui->PiclistWidget->setCurrentItem(nextItem);
        }
    }
}

void Image_Viewer::on_zuoBt_clicked() {
    // 获取当前显示的 QPixmap 对象
    QPixmap currentPixmap = PicShowLabel1->pixmap();
    if (currentPixmap.isNull()) {
        return; // 如果没有显示图片，退出
    }

    // 获取当前图片在列表中的项
    QListWidgetItem *currentItem = ui->PiclistWidget->currentItem();
    if (!currentItem) {
        return; // 没有选中的项，退出
    }

    // 获取当前图片的路径
    QString currentImagePath = currentItem->data(Qt::UserRole).toString();
    if (currentImagePath.isEmpty()) {
        return; // 如果没有路径，退出
    }

    // 获取当前图片所在文件夹路径
    QString folderPath = QFileInfo(currentImagePath).absolutePath();
    QDir directory(folderPath);
    QStringList filters;
    filters << "*.png" << "*.jpg" << "*.jpeg" << "*.bmp" << "*.gif";
    QFileInfoList fileList = directory.entryInfoList(filters, QDir::Files);

    // 排序文件列表以确保顺序
    std::sort(fileList.begin(), fileList.end(), [](const QFileInfo &a, const QFileInfo &b) {
        return a.fileName() < b.fileName();
    });

    // 查找当前图片在文件列表中的位置
    int currentIndex = -1;
    for (int i = 0; i < fileList.size(); ++i) {
        if (fileList[i].filePath() == currentImagePath) {
            currentIndex = i;
            break;
        }
    }

    // 如果找到当前图片并且存在上一张图片
    if (currentIndex > 0) {
        QString prevImagePath = fileList[currentIndex - 1].filePath();
        QImage image(prevImagePath);
        if (!image.isNull()) {
            QPixmap pixmap = QPixmap::fromImage(image);

            // 设置图片大小为 PicShowLabel1 的大小
            QSize labelSize = PicShowLabel1->size();
            QPixmap scaledPixmap = pixmap.scaled(labelSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);

            // 设置缩放后的图片到 PicShowLabel1
            PicShowLabel1->setPixmap(scaledPixmap);

            // 确保图片居中显示
            PicShowLabel1->setAlignment(Qt::AlignCenter);

            // 选中上一张图片
            QListWidgetItem *prevItem = ui->PiclistWidget->findItems(QFileInfo(prevImagePath).fileName(), Qt::MatchExactly).first();
            if (prevItem) {
                ui->PiclistWidget->setCurrentItem(prevItem);
            }
        }
    }
}



void Image_Viewer::on_homeBt_clicked()
{
    MyNavigationController::instance().backToMainPage();
}


void Image_Viewer::on_wallpaperBt_clicked()
{

}


void Image_Viewer::on_pushButton_clicked()
{
    cv::Mat frame;
    cap >> frame;
    if (frame.empty()) {
        qDebug() << "无法读取数据";
        QMessageBox::critical(this, "错误", "无法从摄像头读取数据");
        return;
    }
    QImage img = MatToQImage(frame);
    cameraLabel2->setPixmap(QPixmap::fromImage(img));
    QString savePath = "D:/image/";
    QDir dir(savePath);
    if (!dir.exists()) {
        dir.mkpath(savePath);
    }
    QString fileName = QDateTime::currentDateTime().toString("yyyyMMdd_hhmmss") + ".jpg";
    QString filePath = savePath + fileName;

    bool isSaved = cv::imwrite(filePath.toStdString(), frame);

    if (isSaved) {
        QMessageBox::information(this, "图片保存", "图片已成功保存到：" + filePath);
    } else {
        QMessageBox::critical(this, "错误", "保存图片失败");
    }
}


void Image_Viewer::on_openC_clicked()
{
    if (!cap.isOpened()) {
        cap.open(0); // 打开摄像头
        if (!cap.isOpened()) {
            qDebug() << "无法打开摄像头";
            QMessageBox::critical(this, "错误", "无法打开摄像头");
            return;
        }
        cameraLabel = ui->label;
        cameraLabel2 = ui->label_11;


        timer = new QTimer(this);
        connect(timer, &QTimer::timeout, this, &Image_Viewer::updateCameraFrame);
        timer->start(30); // 更新间隔30ms
        ui->pushButton->setEnabled(true); // 启用保存按钮
    }
}


void Image_Viewer::on_closeC_clicked()
{
    if (cap.isOpened()) {
        cap.release(); // 释放摄像头
        timer->stop(); // 停止定时器
        cameraLabel->clear(); // 清除显示图像
        cameraLabel2->clear(); // 清除显示图像
        ui->pushButton->setEnabled(false); // 禁用保存按钮
    }
}


void Image_Viewer::on_pushButton_2_clicked()
{
    if (!PicShowLabel1->pixmap()) {
        // 如果没有图片，返回
        return;
    }

    // 从 PicShowLabel1 获取当前的 QPixmap
    QPixmap pixmap = PicShowLabel1->pixmap().copy();

    // 将 QPixmap 转换为 QImage
    QImage image = pixmap.toImage();

    // 将 QImage 转换为 cv::Mat
    cv::Mat mat(image.height(), image.width(), CV_8UC4, (void*)image.bits(), image.bytesPerLine());

    // 执行水平翻转
    cv::Mat matMirrored;
    cv::flip(mat, matMirrored, 1); // 1 表示水平翻转

    // 将翻转后的图像转换回 QImage
    QImage imageMirrored(matMirrored.data, matMirrored.cols, matMirrored.rows, matMirrored.step, QImage::Format_RGBA8888);

    // 需要手动管理 QImage 内部的数据内存
    imageMirrored = imageMirrored.copy();  // 复制 QImage 数据以确保其生命周期

    // 将 QImage 转换回 QPixmap
    QPixmap pixmapMirrored = QPixmap::fromImage(imageMirrored);

    // 设置翻转后的 QPixmap 到 PicShowLabel1
    PicShowLabel1->setPixmap(pixmapMirrored);

}


void Image_Viewer::on_huidu_clicked()
{
    if (!PicShowLabel1->pixmap()) {
        // 如果没有图片，返回
        return;
    }
    // 从 PicShowLabel1 获取当前的 QPixmap
    QPixmap pixmap = PicShowLabel1->pixmap().copy();

    // 创建一个 QImage 从 QPixmap
    QImage image = pixmap.toImage();
    QColor oldColor;
    for(int y = 0; y < image.height(); y++)
    {
        for(int x = 0; x < image.width(); x++)
        {
            oldColor = QColor(image.pixel(x,y));
            int average = (oldColor.red() + oldColor.green() + oldColor.blue()) / 3;
            image.setPixel(x, y, qRgb(average, average, average));
        }
    }
    // 将处理后的 QImage 转换回 QPixmap
    QPixmap huiPixmap = QPixmap::fromImage(image);

    // 更新 PicShowLabel1 显示处理后的图像
    PicShowLabel1->setPixmap(huiPixmap);

}


void Image_Viewer::on_horizontalSlider_valueChanged(int value)
{
    if (!PicShowLabel1->pixmap()) {
        // 如果没有图片，返回
        return;
    }

    // 从 PicShowLabel1 获取当前的 QPixmap
    QPixmap pixmap = PicShowLabel1->pixmap().copy();

    // 创建一个 QImage 从 QPixmap
    QImage image = pixmap.toImage(); // origin_path需要换成你的图片路径
    int red, green, blue;
//    int red1, green1, blue1;
    int pixels = image.width() * image.height();
    unsigned int *data = (unsigned int *)image.bits();

    for (int i = 0; i < pixels; ++i) {
        red=qRed(data[i]);
        green=qGreen(data[i]);
        blue=qBlue(data[i]);
        red = red + value;
        red = (red < 0) ? 0 : (red > 255) ? 255 : red;
        green = green + value;
        green = (green < 0) ? 0 : (green > 255) ? 255 : green;
        blue = blue + value;
        blue = (blue < 0) ? 0 : (blue > 255) ? 255 : blue;
        data[i] = qRgba(red, green, blue, qAlpha(data[i]));

//        data[i] = qRgba(red1, green1, blue1, qAlpha(data[i]));
    }
    // 将处理后的 QImage 转换回 QPixmap
    QPixmap huiPixmap = QPixmap::fromImage(image);

    // 更新 PicShowLabel1 显示处理后的图像
    PicShowLabel1->setPixmap(huiPixmap);

}

void Image_Viewer::on_button_clicked(QPushButton* button, QLabel* PicShowLabel1)
{
    QObject::connect(button, &QPushButton::clicked, [PicShowLabel1]() {
        // 从 PicShowLabel1 获取当前的 QPixmap
        QPixmap pixmap = PicShowLabel1->pixmap().copy();

        // 将 QPixmap 转换为 QImage
        QImage image = pixmap.toImage();

        // 定义保存路径
        QString filePath = "D://image/saved_image.png";

        // 保存图像到指定路径
        if (image.save(filePath)) {
            QMessageBox::information(nullptr, "Success", "Image saved successfully to " + filePath);
        } else {
            QMessageBox::critical(nullptr, "错误", "保存图片失败");
        }
    });
}


void Image_Viewer::on_button_clicked()
{
    // 从 PicShowLabel1 获取当前的 QPixmap
    QPixmap pixmap = PicShowLabel1->pixmap().copy();

    // 将 QPixmap 转换为 QImage
    QImage image = pixmap.toImage();

    // 定义保存路径
    QString savePath = "D:/image/";
    QString fileName = QDateTime::currentDateTime().toString("yyyyMMdd_hhmmss") + ".jpg";
    QString filePath = savePath + fileName;
    // 保存图像到指定路径
    if (image.save(filePath)) {
        QMessageBox::information(nullptr, "Success", "Image saved successfully to " + filePath);
    } else {
        QMessageBox::critical(nullptr, "错误", "保存图片失败");
    }
}


void Image_Viewer::on_bianyuanBt_clicked()
{
    // 从 PicShowLabel1 获取当前的 QPixmap
    QPixmap pixmap = PicShowLabel1->pixmap().copy();

    // 将 QPixmap 转换为 QImage
    QImage image = pixmap.toImage();
    QColor color0;
    QColor color1;
    QColor color2;
    QColor color3;
    int  r = 0;
    int g = 0;
    int b = 0;
    int rgb = 0;
    int r1 = 0;
    int g1 = 0;
    int b1 = 0;
    int rgb1 = 0;
    int a = 0;
    for( int y = 0; y < image.height() - 1; y++)
    {
        for(int x = 0; x < image.width() - 1; x++)
        {
            color0 =   QColor ( image.pixel(x,y));
            color1 =   QColor ( image.pixel(x + 1,y));
            color2 =   QColor ( image.pixel(x,y + 1));
            color3 =   QColor ( image.pixel(x + 1,y + 1));
            r = abs(color0.red() - color3.red());
            g = abs(color0.green() - color3.green());
            b = abs(color0.blue() - color3.blue());
            rgb = r + g + b;

            r1 = abs(color1.red() - color2.red());
            g1= abs(color1.green() - color2.green());
            b1 = abs(color1.blue() - color2.blue());
            rgb1 = r1 + g1 + b1;

            a = rgb + rgb1;
            a = a>255?255:a;

            image.setPixel(x,y,qRgb(a,a,a));
        }
    }
    // 将处理后的 QImage 转换回 QPixmap
    QPixmap bianyuanPixmap = QPixmap::fromImage(image);

    // 更新 PicShowLabel1 显示处理后的图像
    PicShowLabel1->setPixmap(bianyuanPixmap);
}
cv::Mat QImageToMat(const QImage &image) {
    return cv::Mat(image.height(), image.width(), CV_8UC4, (void*)image.constBits(), image.bytesPerLine()).clone();
}

// 这个函数将cv::Mat转换为QImage
QImage MatToQImage(const cv::Mat &mat) {
    QImage image(mat.data, mat.cols, mat.rows, mat.step, QImage::Format_RGB888);
    return image.rgbSwapped();  // OpenCV使用BGR格式，QImage使用RGB格式
}
// cv::Mat QImageToMat(const QImage &img) {
//     switch (img.format()) {
//     case QImage::Format_RGB888: {
//         cv::Mat mat(img.height(), img.width(), CV_8UC3, (void*)img.bits(), img.bytesPerLine());
//         return mat;
//     }
//     case QImage::Format_RGBA8888: {
//         cv::Mat mat(img.height(), img.width(), CV_8UC4, (void*)img.bits(), img.bytesPerLine());
//         return mat;
//     }
//     default:
//         qDebug() << "Unsupported QImage format";
//         return cv::Mat();
//     }
// }

// QImage MatToQImage(const cv::Mat &mat) {
//     switch (mat.type()) {
//     case CV_8UC3: {
//         QImage img(mat.data, mat.cols, mat.rows, mat.step, QImage::Format_RGB888);
//         return img.copy();
//     }
//     case CV_8UC4: {
//         QImage img(mat.data, mat.cols, mat.rows, mat.step, QImage::Format_RGBA8888);
//         return img.copy();
//     }
//     default:
//         qDebug() << "Unsupported cv::Mat type";
//         return QImage();
//     }
// }

void Image_Viewer::on_renlian_clicked()
{
    cv::CascadeClassifier faceCascade;
    qDebug() << "开始加载人脸级联分类器";
    // 加载人脸级联分类器xml文件
    if (!faceCascade.load("D:/lib/haarcascade_frontalface_alt2.xml"))
    {
        qDebug() << "无法加载人脸级联分类器";
        return;
    }

    // 从PicShowLabel1获取图像
    QPixmap pixmap = PicShowLabel1->pixmap(Qt::ReturnByValue);
    QImage img = pixmap.toImage();

    // 将QImage转换为cv::Mat
    cv::Mat image = QImageToMat(img);

    // 将图像转换为灰度图像，以便进行人脸检测
    cv::Mat grayImage;
    cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
    qDebug() << "图像转换成功";


    // 人脸检测
    std::vector<cv::Rect> faces;
    faceCascade.detectMultiScale(grayImage, faces, 1.1, 3);
    qDebug() << "检测到的人脸数量：" << faces.size();



    // 假设只显示第一个检测到的人脸
    cv::Rect face = faces[0];
    cv::Mat faceROI = image(face);

    if (faces.empty()) {
        qDebug() << "没有检测到人脸";
        return;
    }
    cv::imshow("Face ROI", faceROI);


}

